home *** CD-ROM | disk | FTP | other *** search
/ Champak 74 / Volume 74 My Disc - Damaged.iso / Games / sketch.swf / scripts / DefineSprite_52_TMPo3jyprglg9 / frame_1 / PlaceObject2_51_301 / CLIPACTIONRECORD onClipEvent(load).as
Text File  |  2008-08-07  |  67KB  |  1,083 lines

  1. onClipEvent(load){
  2.    function ┬º\x01\x02┬º()
  3.    {
  4.       return 256 % 511 * 5;
  5.    }
  6.    var ┬º\x01┬º = -438 + "\x01\x02"();
  7.    loop0:
  8.    while(true)
  9.    {
  10.       if(eval("\x01") == 842)
  11.       {
  12.          set("\x01",eval("\x01") - 803);
  13.          ┬º┬ºpush(true);
  14.       }
  15.       else if(eval("\x01") == 486)
  16.       {
  17.          set("\x01",eval("\x01") + 63);
  18.          ┬º┬ºpush("\x0f");
  19.          ┬º┬ºpush(1);
  20.       }
  21.       else
  22.       {
  23.          if(eval("\x01") == 470)
  24.          {
  25.             set("\x01",eval("\x01") + 63);
  26.             break;
  27.          }
  28.          if(eval("\x01") == 533)
  29.          {
  30.             set("\x01",eval("\x01") + 421);
  31.          }
  32.          else if(eval("\x01") == 289)
  33.          {
  34.             set("\x01",eval("\x01") + 586);
  35.          }
  36.          else
  37.          {
  38.             if(eval("\x01") == 9)
  39.             {
  40.                set("\x01",eval("\x01") + 38);
  41.                break;
  42.             }
  43.             if(eval("\x01") == 35)
  44.             {
  45.                set("\x01",eval("\x01") + 919);
  46.             }
  47.             else if(eval("\x01") == 954)
  48.             {
  49.                set("\x01",eval("\x01") - 757);
  50.                ┬º┬ºpush(true);
  51.             }
  52.             else if(eval("\x01") == 516)
  53.             {
  54.                set("\x01",eval("\x01") + 153);
  55.                if(function ┬º\x01\x02┬º()
  56.                {
  57.                   return 256 % 511 * 5;
  58.                })
  59.                {
  60.                   set("\x01",eval("\x01") - 313);
  61.                }
  62.             }
  63.             else if(eval("\x01") == 39)
  64.             {
  65.                set("\x01",eval("\x01") + 431);
  66.                if(function ┬º\x01\x02┬º()
  67.                {
  68.                   return 256 % 511 * 5;
  69.                })
  70.                {
  71.                   set("\x01",eval("\x01") + 63);
  72.                }
  73.             }
  74.             else if(eval("\x01") == 197)
  75.             {
  76.                set("\x01",eval("\x01") - 188);
  77.                if(function ┬º\x01\x02┬º()
  78.                {
  79.                   return 256 % 511 * 5;
  80.                })
  81.                {
  82.                   set("\x01",eval("\x01") + 38);
  83.                }
  84.             }
  85.             else if(eval("\x01") == 84)
  86.             {
  87.                set("\x01",eval("\x01") - 81);
  88.                ┬º┬ºpush("\x0f");
  89.             }
  90.             else if(eval("\x01") == 47)
  91.             {
  92.                set("\x01",eval("\x01") + 828);
  93.             }
  94.             else if(eval("\x01") == 166)
  95.             {
  96.                set("\x01",eval("\x01") + 320);
  97.             }
  98.             else if(eval("\x01") == 875)
  99.             {
  100.                set("\x01",eval("\x01") - 359);
  101.                ┬º┬ºpush(true);
  102.             }
  103.             else
  104.             {
  105.                if(eval("\x01") == 669)
  106.                {
  107.                   set("\x01",eval("\x01") - 313);
  108.                   break;
  109.                }
  110.                if(eval("\x01") == 356)
  111.                {
  112.                   set("\x01",eval("\x01") + 285);
  113.                }
  114.                else if(eval("\x01") == 569)
  115.                {
  116.                   set("\x01",eval("\x01") + 72);
  117.                }
  118.                else
  119.                {
  120.                   if(eval("\x01") == 61)
  121.                   {
  122.                      set("\x01",eval("\x01") + 646);
  123.                      setProperty("∩┐╜\x04", _alpha, 5);
  124.                      set("1!∩┐╜∩┐╜∩┐╜",getProperty("∩┐╜\x04", _X));
  125.                      set(┬º┬ºconstant(2),getProperty("∩┐╜\x04", _Y));
  126.                      setProperty("∩┐╜\x04", _X, random(320) - 160);
  127.                      setProperty("∩┐╜\x04", _Y, random(240) - 120);
  128.                      set(┬º┬ºconstant(3),eval(┬º┬ºconstant(4))[┬º┬ºconstant(5)]);
  129.                      break;
  130.                   }
  131.                   if(eval("\x01") == 641)
  132.                   {
  133.                      set("\x01",eval("\x01") + 241);
  134.                      ┬º┬ºpush(true);
  135.                   }
  136.                   else
  137.                   {
  138.                      if(eval("\x01") == 20)
  139.                      {
  140.                         set("\x01",eval("\x01") + 146);
  141.                         loop1:
  142.                         while(true)
  143.                         {
  144.                            set(┬º┬ºpop(),┬º┬ºpop() + function ┬º\x01\x02┬º()
  145.                            {
  146.                               return 256 % 511 * 5;
  147.                            });
  148.                            while(true)
  149.                            {
  150.                               if(eval("\x01") == 934)
  151.                               {
  152.                                  set("\x01",eval("\x01") - 919);
  153.                                  ┬º┬ºpush(true);
  154.                                  continue;
  155.                               }
  156.                               if(eval("\x01") == 574)
  157.                               {
  158.                                  break loop1;
  159.                               }
  160.                               if(eval("\x01") == 516)
  161.                               {
  162.                                  set("\x01",eval("\x01") + 263);
  163.                                  ┬º┬ºpush("\x0f");
  164.                                  continue;
  165.                               }
  166.                               if(eval("\x01") == 902)
  167.                               {
  168.                                  set("\x01",eval("\x01") - 398);
  169.                                  continue;
  170.                               }
  171.                               if(eval("\x01") == 814)
  172.                               {
  173.                                  set("\x01",eval("\x01") + 42);
  174.                                  ┬º┬ºpush(true);
  175.                                  continue;
  176.                               }
  177.                               if(eval("\x01") != 226)
  178.                               {
  179.                                  if(eval("\x01") == 856)
  180.                                  {
  181.                                     set("\x01",eval("\x01") - 630);
  182.                                     if(┬º┬ºpop())
  183.                                     {
  184.                                        set("\x01",eval("\x01") + 676);
  185.                                     }
  186.                                  }
  187.                                  else if(eval("\x01") == 961)
  188.                                  {
  189.                                     set("\x01",eval("\x01") - 445);
  190.                                     var ┬º┬ºpop() = ┬º┬ºpop();
  191.                                  }
  192.                                  else if(eval("\x01") == 760)
  193.                                  {
  194.                                     set("\x01",eval("\x01") - 256);
  195.                                  }
  196.                                  else if(eval("\x01") == 254)
  197.                                  {
  198.                                     set("\x01",eval("\x01") + 560);
  199.                                  }
  200.                                  else if(eval("\x01") == 550)
  201.                                  {
  202.                                     set("\x01",eval("\x01") + 414);
  203.                                     ┬º┬ºpush(!┬º┬ºpop());
  204.                                  }
  205.                                  else if(eval("\x01") == 964)
  206.                                  {
  207.                                     set("\x01",eval("\x01") - 433);
  208.                                     if(┬º┬ºpop())
  209.                                     {
  210.                                        set("\x01",eval("\x01") + 70);
  211.                                     }
  212.                                  }
  213.                                  else if(eval("\x01") == 906)
  214.                                  {
  215.                                     set("\x01",eval("\x01") - 92);
  216.                                  }
  217.                                  else if(eval("\x01") == 504)
  218.                                  {
  219.                                     set("\x01",eval("\x01") + 457);
  220.                                     ┬º┬ºpush("\x0f");
  221.                                     ┬º┬ºpush(1);
  222.                                  }
  223.                                  else if(eval("\x01") == 779)
  224.                                  {
  225.                                     set("\x01",eval("\x01") - 229);
  226.                                     ┬º┬ºpush(eval(┬º┬ºpop()));
  227.                                  }
  228.                                  else
  229.                                  {
  230.                                     if(eval("\x01") == 531)
  231.                                     {
  232.                                        break;
  233.                                     }
  234.                                     if(eval("\x01") == 601)
  235.                                     {
  236.                                        set("\x01",eval("\x01") - 420);
  237.                                        _alpha = 5;
  238.                                        ix = _X;
  239.                                        iy = _Y;
  240.                                        _X = random(320) - 160;
  241.                                        _Y = random(240) - 120;
  242.                                        onEnterFrame = _parent.oef;
  243.                                        break loop0;
  244.                                     }
  245.                                     if(eval("\x01") != 15)
  246.                                     {
  247.                                        if(eval("\x01") == 181)
  248.                                        {
  249.                                           set("\x01",eval("\x01") - 181);
  250.                                           break loop0;
  251.                                        }
  252.                                        break loop0;
  253.                                     }
  254.                                     set("\x01",eval("\x01") + 559);
  255.                                     if(┬º┬ºpop())
  256.                                     {
  257.                                        set("\x01",eval("\x01") + 332);
  258.                                     }
  259.                                  }
  260.                                  continue;
  261.                               }
  262.                               set("\x01",eval("\x01") + 676);
  263.                               loop3:
  264.                               while(true)
  265.                               {
  266.                                  if(┬º┬ºpop() == 897)
  267.                                  {
  268.                                     set("\x01",eval("\x01") - 747);
  269.                                     if(┬º┬ºpop())
  270.                                     {
  271.                                        set("\x01",eval("\x01") + 609);
  272.                                     }
  273.                                  }
  274.                                  else
  275.                                  {
  276.                                     if(eval("\x01") == 150)
  277.                                     {
  278.                                        set("\x01",eval("\x01") + 609);
  279.                                        addr1229:
  280.                                        if(eval(┬º┬ºpop()) != 770)
  281.                                        {
  282.                                           if(eval("\x01") != 101)
  283.                                           {
  284.                                              if(eval("\x01") == 1)
  285.                                              {
  286.                                                 set("\x01",eval("\x01") + 321);
  287.                                                 if(!┬º┬ºpop())
  288.                                                 {
  289.                                                    addr969:
  290.                                                    if(eval("\x01") == 520)
  291.                                                    {
  292.                                                       set("\x01",eval("\x01") - 142);
  293.                                                       ┬º┬ºgoto(addr969);
  294.                                                       ┬º┬ºpush(true);
  295.                                                    }
  296.                                                    if(eval("\x01") == 378)
  297.                                                    {
  298.                                                       set("\x01",eval("\x01") + 392);
  299.                                                       if(!┬º┬ºpop())
  300.                                                       {
  301.                                                          addr1006:
  302.                                                          ┬º┬ºgoto(addr969);
  303.                                                       }
  304.                                                       set("\x01",eval("\x01") - 607);
  305.                                                       ┬º┬ºgoto(addr1006);
  306.                                                    }
  307.                                                    if(eval("\x01") == 889)
  308.                                                    {
  309.                                                       set("\x01",eval("\x01") - 795);
  310.                                                       ┬º┬ºgoto(addr969);
  311.                                                       ┬º┬ºpush("\x0f");
  312.                                                    }
  313.                                                    if(eval("\x01") == 163)
  314.                                                    {
  315.                                                       set("\x01",eval("\x01") + 630);
  316.                                                       ┬º┬ºgoto(addr969);
  317.                                                    }
  318.                                                    if(eval("\x01") == 654)
  319.                                                    {
  320.                                                       set("\x01",eval("\x01") - 569);
  321.                                                       ┬º┬ºgoto(addr969);
  322.                                                    }
  323.                                                    if(eval("\x01") == 824)
  324.                                                    {
  325.                                                       set("\x01",eval("\x01") - 170);
  326.                                                       if(!┬º┬ºpop())
  327.                                                       {
  328.                                                          addr1068:
  329.                                                          ┬º┬ºgoto(addr969);
  330.                                                       }
  331.                                                       set("\x01",eval("\x01") - 569);
  332.                                                       ┬º┬ºgoto(addr1068);
  333.                                                    }
  334.                                                    if(eval("\x01") == 977)
  335.                                                    {
  336.                                                       set("\x01",eval("\x01") - 957);
  337.                                                       ┬º┬ºgoto(addr969);
  338.                                                    }
  339.                                                    if(eval("\x01") == 51)
  340.                                                    {
  341.                                                       set("\x01",eval("\x01") + 40);
  342.                                                       ┬º┬ºgoto(addr969);
  343.                                                       ┬º┬ºpush(true);
  344.                                                    }
  345.                                                    if(eval("\x01") != 85)
  346.                                                    {
  347.                                                       if(eval("\x01") == 94)
  348.                                                       {
  349.                                                          set("\x01",eval("\x01") + 677);
  350.                                                          ┬º┬ºgoto(addr969);
  351.                                                          ┬º┬ºpush(eval(┬º┬ºpop()));
  352.                                                       }
  353.                                                       if(eval("\x01") == 91)
  354.                                                       {
  355.                                                          set("\x01",eval("\x01") + 626);
  356.                                                          if(!┬º┬ºpop())
  357.                                                          {
  358.                                                             addr1145:
  359.                                                             ┬º┬ºgoto(addr969);
  360.                                                          }
  361.                                                          set("\x01",eval("\x01") - 8);
  362.                                                          ┬º┬ºgoto(addr1145);
  363.                                                       }
  364.                                                       if(eval("\x01") == 771)
  365.                                                       {
  366.                                                          set("\x01",eval("\x01") + 53);
  367.                                                          ┬º┬ºgoto(addr969);
  368.                                                          ┬º┬ºpush(!┬º┬ºpop());
  369.                                                       }
  370.                                                       if(eval("\x01") == 120)
  371.                                                       {
  372.                                                          set("\x01",eval("\x01") - 69);
  373.                                                          ┬º┬ºgoto(addr969);
  374.                                                       }
  375.                                                       if(eval("\x01") == 794)
  376.                                                       {
  377.                                                          set("\x01",eval("\x01") + 95);
  378.                                                          var ┬º┬ºpop() = ┬º┬ºpop();
  379.                                                          ┬º┬ºgoto(addr969);
  380.                                                       }
  381.                                                       if(eval("\x01") == 20)
  382.                                                       {
  383.                                                          set("\x01",eval("\x01") + 774);
  384.                                                          ┬º┬ºgoto(addr969);
  385.                                                          ┬º┬ºpush("\x0f");
  386.                                                          ┬º┬ºpush(1);
  387.                                                       }
  388.                                                       if(eval("\x01") == 709)
  389.                                                       {
  390.                                                          set("\x01",eval("\x01") - 689);
  391.                                                          ┬º┬ºgoto(addr969);
  392.                                                       }
  393.                                                       addr592:
  394.                                                       if(eval("\x01") != 717)
  395.                                                       {
  396.                                                          ┬º┬ºgoto(addr1229);
  397.                                                          ┬º┬ºpush("\x01");
  398.                                                       }
  399.                                                       set("\x01",eval("\x01") - 8);
  400.                                                       set(┬º┬ºpop(),┬º┬ºpop() + ┬º┬ºpop());
  401.                                                       addr503:
  402.                                                       if(eval("\x01") == 621)
  403.                                                       {
  404.                                                          set("\x01",eval("\x01") - 115);
  405.                                                          ┬º┬ºgoto(addr503);
  406.                                                          ┬º┬ºpush(true);
  407.                                                       }
  408.                                                       if(eval("\x01") == 597)
  409.                                                       {
  410.                                                          set("\x01",eval("\x01") - 175);
  411.                                                          ┬º┬ºgoto(addr503);
  412.                                                       }
  413.                                                       addr594:
  414.                                                       if(eval("\x01") != 69)
  415.                                                       {
  416.                                                          if(eval("\x01") == 663)
  417.                                                          {
  418.                                                             set("\x01",eval("\x01") - 45);
  419.                                                             ┬º┬ºgoto(addr503);
  420.                                                          }
  421.                                                          if(eval("\x01") == 422)
  422.                                                          {
  423.                                                             set("\x01",eval("\x01") - 414);
  424.                                                             ┬º┬ºgoto(addr503);
  425.                                                             ┬º┬ºpush(true);
  426.                                                          }
  427.                                                          if(eval("\x01") == 506)
  428.                                                          {
  429.                                                             set("\x01",eval("\x01") - 451);
  430.                                                             if(!┬º┬ºpop())
  431.                                                             {
  432.                                                                ┬º┬ºgoto(addr594);
  433.                                                             }
  434.                                                             ┬º┬ºgoto(addr592);
  435.                                                             ┬º┬ºpush("\x01");
  436.                                                             ┬º┬ºpush(eval("\x01"));
  437.                                                             ┬º┬ºpush(608);
  438.                                                          }
  439.                                                          if(eval("\x01") == 8)
  440.                                                          {
  441.                                                             set("\x01",eval("\x01") + 639);
  442.                                                             if(!┬º┬ºpop())
  443.                                                             {
  444.                                                                addr615:
  445.                                                                ┬º┬ºgoto(addr592);
  446.                                                             }
  447.                                                             set("\x01",eval("\x01") - 42);
  448.                                                             ┬º┬ºgoto(addr615);
  449.                                                          }
  450.                                                          if(eval("\x01") == 435)
  451.                                                          {
  452.                                                             set("\x01",eval("\x01") + 240);
  453.                                                             ┬º┬ºgoto(addr592);
  454.                                                          }
  455.                                                          if(eval("\x01") != 55)
  456.                                                          {
  457.                                                             if(eval("\x01") == 82)
  458.                                                             {
  459.                                                                set("\x01",eval("\x01") - 8);
  460.                                                                if(!┬º┬ºpop())
  461.                                                                {
  462.                                                                   addr663:
  463.                                                                   ┬º┬ºgoto(addr592);
  464.                                                                }
  465.                                                                set("\x01",eval("\x01") + 523);
  466.                                                                ┬º┬ºgoto(addr663);
  467.                                                             }
  468.                                                             if(eval("\x01") != 647)
  469.                                                             {
  470.                                                                if(eval("\x01") == 334)
  471.                                                                {
  472.                                                                   set("\x01",eval("\x01") + 88);
  473.                                                                   ┬º┬ºgoto(addr592);
  474.                                                                }
  475.                                                                if(eval("\x01") != 74)
  476.                                                                {
  477.                                                                   if(eval("\x01") == 605)
  478.                                                                   {
  479.                                                                      set("\x01",eval("\x01") + 208);
  480.                                                                      ┬º┬ºgoto(addr592);
  481.                                                                   }
  482.                                                                   if(eval("\x01") == 618)
  483.                                                                   {
  484.                                                                      set("\x01",eval("\x01") - 536);
  485.                                                                      ┬º┬ºgoto(addr592);
  486.                                                                      ┬º┬ºpush(true);
  487.                                                                   }
  488.                                                                   if(eval("\x01") != 805)
  489.                                                                   {
  490.                                                                      if(eval("\x01") == 606)
  491.                                                                      {
  492.                                                                         set("\x01",eval("\x01") + 199);
  493.                                                                         if(!┬º┬ºpop())
  494.                                                                         {
  495.                                                                            addr764:
  496.                                                                            ┬º┬ºgoto(addr592);
  497.                                                                         }
  498.                                                                         set("\x01",eval("\x01") - 606);
  499.                                                                         ┬º┬ºgoto(addr764);
  500.                                                                      }
  501.                                                                      if(eval("\x01") == 85)
  502.                                                                      {
  503.                                                                         set("\x01",eval("\x01") + 862);
  504.                                                                         var ┬º┬ºpop() = ┬º┬ºpop();
  505.                                                                         ┬º┬ºgoto(addr592);
  506.                                                                      }
  507.                                                                      if(eval("\x01") == 947)
  508.                                                                      {
  509.                                                                         set("\x01",eval("\x01") - 526);
  510.                                                                         ┬º┬ºgoto(addr592);
  511.                                                                         ┬º┬ºpush("\x0f");
  512.                                                                      }
  513.                                                                      if(eval("\x01") == 520)
  514.                                                                      {
  515.                                                                         set("\x01",eval("\x01") + 98);
  516.                                                                         ┬º┬ºgoto(addr592);
  517.                                                                      }
  518.                                                                      if(eval("\x01") == 408)
  519.                                                                      {
  520.                                                                         set("\x01",eval("\x01") + 405);
  521.                                                                         ┬º┬ºgoto(addr592);
  522.                                                                      }
  523.                                                                      if(eval("\x01") == 813)
  524.                                                                      {
  525.                                                                         set("\x01",eval("\x01") - 207);
  526.                                                                         ┬º┬ºgoto(addr592);
  527.                                                                         ┬º┬ºpush(true);
  528.                                                                      }
  529.                                                                      if(eval("\x01") == 199)
  530.                                                                      {
  531.                                                                         set("\x01",eval("\x01") + 476);
  532.                                                                         ┬º┬ºgoto(addr592);
  533.                                                                      }
  534.                                                                      if(eval("\x01") == 675)
  535.                                                                      {
  536.                                                                         set("\x01",eval("\x01") - 590);
  537.                                                                         ┬º┬ºgoto(addr592);
  538.                                                                         ┬º┬ºpush("\x0f");
  539.                                                                         ┬º┬ºpush(1);
  540.                                                                      }
  541.                                                                      if(eval("\x01") == 286)
  542.                                                                      {
  543.                                                                         set("\x01",eval("\x01") + 549);
  544.                                                                         ┬º┬ºgoto(addr592);
  545.                                                                         ┬º┬ºpush(!┬º┬ºpop());
  546.                                                                      }
  547.                                                                      if(eval("\x01") == 421)
  548.                                                                      {
  549.                                                                         set("\x01",eval("\x01") - 135);
  550.                                                                         ┬º┬ºgoto(addr592);
  551.                                                                         ┬º┬ºpush(eval(┬º┬ºpop()));
  552.                                                                      }
  553.                                                                      if(eval("\x01") == 835)
  554.                                                                      {
  555.                                                                         set("\x01",eval("\x01") - 247);
  556.                                                                         if(!┬º┬ºpop())
  557.                                                                         {
  558.                                                                            addr910:
  559.                                                                            ┬º┬ºgoto(addr592);
  560.                                                                         }
  561.                                                                         set("\x01",eval("\x01") - 519);
  562.                                                                         ┬º┬ºgoto(addr910);
  563.                                                                      }
  564.                                                                      if(eval("\x01") == 588)
  565.                                                                      {
  566.                                                                         set("\x01",eval("\x01") - 519);
  567.                                                                         ┬º┬ºgoto(addr592);
  568.                                                                      }
  569.                                                                      if(eval("\x01") == 797)
  570.                                                                      {
  571.                                                                         set("\x01",eval("\x01") - 797);
  572.                                                                         break loop0;
  573.                                                                      }
  574.                                                                      break loop0;
  575.                                                                   }
  576.                                                                   set("\x01",eval("\x01") - 606);
  577.                                                                   break loop0;
  578.                                                                }
  579.                                                                set("\x01",eval("\x01") + 523);
  580.                                                                break loop0;
  581.                                                             }
  582.                                                             set("\x01",eval("\x01") - 42);
  583.                                                             addr445:
  584.                                                             if(┬º┬ºpop() == ┬º┬ºpop())
  585.                                                             {
  586.                                                                set("\x01",eval("\x01") - 487);
  587.                                                                addr32:
  588.                                                                ┬º┬ºpush(!┬º┬ºpop());
  589.                                                                if(eval("\x01") == 228)
  590.                                                                {
  591.                                                                   set("\x01",eval("\x01") + 526);
  592.                                                                   ┬º┬ºgoto(addr32);
  593.                                                                   ┬º┬ºpush(true);
  594.                                                                }
  595.                                                                if(eval("\x01") == 161)
  596.                                                                {
  597.                                                                   set("\x01",eval("\x01") - 88);
  598.                                                                   ┬º┬ºgoto(addr32);
  599.                                                                }
  600.                                                                if(eval("\x01") == 159)
  601.                                                                {
  602.                                                                   set("\x01",eval("\x01") + 439);
  603.                                                                   ┬º┬ºgoto(addr32);
  604.                                                                }
  605.                                                                if(eval("\x01") == 649)
  606.                                                                {
  607.                                                                   set("\x01",eval("\x01") - 497);
  608.                                                                   ┬º┬ºgoto(addr32);
  609.                                                                   ┬º┬ºpush(true);
  610.                                                                }
  611.                                                                if(eval("\x01") == 905)
  612.                                                                {
  613.                                                                   set("\x01",eval("\x01") - 307);
  614.                                                                   ┬º┬ºgoto(addr32);
  615.                                                                }
  616.                                                                if(eval("\x01") != 755)
  617.                                                                {
  618.                                                                   if(eval("\x01") == 263)
  619.                                                                   {
  620.                                                                      set("\x01",eval("\x01") + 279);
  621.                                                                      if(!┬º┬ºpop())
  622.                                                                      {
  623.                                                                         addr139:
  624.                                                                         ┬º┬ºgoto(addr32);
  625.                                                                      }
  626.                                                                      set("\x01",eval("\x01") - 171);
  627.                                                                      ┬º┬ºgoto(addr139);
  628.                                                                   }
  629.                                                                   if(eval("\x01") == 754)
  630.                                                                   {
  631.                                                                      set("\x01",eval("\x01") + 49);
  632.                                                                      if(!┬º┬ºpop())
  633.                                                                      {
  634.                                                                         addr160:
  635.                                                                         ┬º┬ºgoto(addr32);
  636.                                                                      }
  637.                                                                      set("\x01",eval("\x01") - 644);
  638.                                                                      ┬º┬ºgoto(addr160);
  639.                                                                   }
  640.                                                                   if(eval("\x01") == 152)
  641.                                                                   {
  642.                                                                      set("\x01",eval("\x01") + 603);
  643.                                                                      if(!┬º┬ºpop())
  644.                                                                      {
  645.                                                                         addr181:
  646.                                                                         ┬º┬ºgoto(addr32);
  647.                                                                      }
  648.                                                                      set("\x01",eval("\x01") - 714);
  649.                                                                      ┬º┬ºgoto(addr181);
  650.                                                                   }
  651.                                                                   if(eval("\x01") == 932)
  652.                                                                   {
  653.                                                                      set("\x01",eval("\x01") - 283);
  654.                                                                      ┬º┬ºgoto(addr32);
  655.                                                                   }
  656.                                                                   if(eval("\x01") == 41)
  657.                                                                   {
  658.                                                                      set("\x01",eval("\x01") + 32);
  659.                                                                      ┬º┬ºgoto(addr32);
  660.                                                                   }
  661.                                                                   if(eval("\x01") != 803)
  662.                                                                   {
  663.                                                                      if(eval("\x01") == 73)
  664.                                                                      {
  665.                                                                         set("\x01",eval("\x01") + 702);
  666.                                                                         ┬º┬ºgoto(addr32);
  667.                                                                         ┬º┬ºpush("\x0f");
  668.                                                                         ┬º┬ºpush(1);
  669.                                                                      }
  670.                                                                      if(eval("\x01") == 90)
  671.                                                                      {
  672.                                                                         set("\x01",eval("\x01") + 473);
  673.                                                                         if(!┬º┬ºpop())
  674.                                                                         {
  675.                                                                            addr256:
  676.                                                                            ┬º┬ºgoto(addr32);
  677.                                                                         }
  678.                                                                         set("\x01",eval("\x01") - 164);
  679.                                                                         ┬º┬ºgoto(addr256);
  680.                                                                      }
  681.                                                                      if(eval("\x01") == 598)
  682.                                                                      {
  683.                                                                         set("\x01",eval("\x01") + 381);
  684.                                                                         ┬º┬ºgoto(addr32);
  685.                                                                         ┬º┬ºpush(true);
  686.                                                                      }
  687.                                                                      if(eval("\x01") == 979)
  688.                                                                      {
  689.                                                                         set("\x01",eval("\x01") - 894);
  690.                                                                         if(!┬º┬ºpop())
  691.                                                                         {
  692.                                                                            addr291:
  693.                                                                            ┬º┬ºgoto(addr32);
  694.                                                                         }
  695.                                                                         set("\x01",eval("\x01") - 47);
  696.                                                                         ┬º┬ºgoto(addr291);
  697.                                                                      }
  698.                                                                      if(eval("\x01") != 85)
  699.                                                                      {
  700.                                                                         if(eval("\x01") == 775)
  701.                                                                         {
  702.                                                                            set("\x01",eval("\x01") - 593);
  703.                                                                            var ┬º┬ºpop() = ┬º┬ºpop();
  704.                                                                            ┬º┬ºgoto(addr32);
  705.                                                                         }
  706.                                                                         if(eval("\x01") == 399)
  707.                                                                         {
  708.                                                                            set("\x01",eval("\x01") + 250);
  709.                                                                            ┬º┬ºgoto(addr32);
  710.                                                                         }
  711.                                                                         if(eval("\x01") == 182)
  712.                                                                         {
  713.                                                                            set("\x01",eval("\x01") + 690);
  714.                                                                            ┬º┬ºgoto(addr32);
  715.                                                                            ┬º┬ºpush("\x0f");
  716.                                                                         }
  717.                                                                         if(eval("\x01") != 371)
  718.                                                                         {
  719.                                                                            if(eval("\x01") == 872)
  720.                                                                            {
  721.                                                                               set("\x01",eval("\x01") - 122);
  722.                                                                               ┬º┬ºgoto(addr32);
  723.                                                                               ┬º┬ºpush(eval(┬º┬ºpop()));
  724.                                                                            }
  725.                                                                            if(eval("\x01") == 542)
  726.                                                                            {
  727.                                                                               set("\x01",eval("\x01") - 171);
  728.                                                                               ┬º┬ºgoto(addr32);
  729.                                                                            }
  730.                                                                            if(eval("\x01") == 38)
  731.                                                                            {
  732.                                                                               set("\x01",eval("\x01") + 946);
  733.                                                                               ┬º┬ºgoto(addr32);
  734.                                                                            }
  735.                                                                            if(eval("\x01") == 221)
  736.                                                                            {
  737.                                                                               set("\x01",eval("\x01") + 763);
  738.                                                                               ┬º┬ºgoto(addr32);
  739.                                                                            }
  740.                                                                            if(eval("\x01") == 984)
  741.                                                                            {
  742.                                                                               set("\x01",eval("\x01") - 894);
  743.                                                                               ┬º┬ºgoto(addr32);
  744.                                                                               ┬º┬ºpush(true);
  745.                                                                            }
  746.                                                                            if(eval("\x01") != 563)
  747.                                                                            {
  748.                                                                               ┬º┬ºgoto(addr445);
  749.                                                                               ┬º┬ºpush(eval("\x01"));
  750.                                                                               ┬º┬ºpush(750);
  751.                                                                            }
  752.                                                                            set("\x01",eval("\x01") - 164);
  753.                                                                            break loop0;
  754.                                                                         }
  755.                                                                         set("\x01",eval("\x01") - 204);
  756.                                                                         _alpha = 5;
  757.                                                                         ix = _X;
  758.                                                                         iy = _Y;
  759.                                                                         _X = random(320) - 160;
  760.                                                                         _Y = random(240) - 120;
  761.                                                                         onEnterFrame = _parent.oef;
  762.                                                                         break loop0;
  763.                                                                      }
  764.                                                                      set("\x01",eval("\x01") - 47);
  765.                                                                      break loop0;
  766.                                                                   }
  767.                                                                   set("\x01",eval("\x01") - 644);
  768.                                                                   break loop0;
  769.                                                                }
  770.                                                                set("\x01",eval("\x01") - 714);
  771.                                                                break loop0;
  772.                                                             }
  773.                                                             if(eval("\x01") == 167)
  774.                                                             {
  775.                                                                set("\x01",eval("\x01") - 167);
  776.                                                                break loop0;
  777.                                                             }
  778.                                                             break loop0;
  779.                                                          }
  780.                                                          set("\x01",eval("\x01") + 608);
  781.                                                          break loop0;
  782.                                                       }
  783.                                                       set("\x01",eval("\x01") + 728);
  784.                                                       setProperty("∩┐╜∩┐╜\x16∩┐╜∩┐╜", _alpha, 5);
  785.                                                       set("∩┐╜\"∩┐╜",getProperty("∩┐╜∩┐╜\x16∩┐╜∩┐╜", _X));
  786.                                                       set("?∩┐╜",getProperty("∩┐╜∩┐╜\x16∩┐╜∩┐╜", _Y));
  787.                                                       setProperty("∩┐╜∩┐╜\x16∩┐╜∩┐╜", _X, random(320) - 160);
  788.                                                       setProperty("∩┐╜∩┐╜\x16∩┐╜∩┐╜", _Y, random(240) - 120);
  789.                                                       set("z_∩┐╜D",eval(┬º┬ºconstant(4))[┬º┬ºconstant(5)]);
  790.                                                       break loop0;
  791.                                                    }
  792.                                                    set("\x01",eval("\x01") + 16);
  793.                                                    setProperty("∩┐╜∩┐╜pq", _alpha, 5);
  794.                                                    set("o∩┐╜",getProperty("∩┐╜∩┐╜pq", _X));
  795.                                                    set("f∩┐╜R0",getProperty("∩┐╜∩┐╜pq", _Y));
  796.                                                    setProperty("∩┐╜∩┐╜pq", _X, random(320) - 160);
  797.                                                    setProperty("∩┐╜∩┐╜pq", _Y, random(240) - 120);
  798.                                                    set(┬º┬ºconstant(3),eval(┬º┬ºconstant(4))[┬º┬ºconstant(5)]);
  799.                                                    break loop0;
  800.                                                    addr1274:
  801.                                                 }
  802.                                                 set("\x01",eval("\x01") - 207);
  803.                                                 ┬º┬ºgoto(addr1274);
  804.                                              }
  805.                                              if(eval("\x01") == 115)
  806.                                              {
  807.                                                 set("\x01",eval("\x01") - 64);
  808.                                                 ┬º┬ºgoto(addr969);
  809.                                              }
  810.                                              if(eval("\x01") != 322)
  811.                                              {
  812.                                                 if(eval("\x01") == 793)
  813.                                                 {
  814.                                                    set("\x01",eval("\x01") - 792);
  815.                                                    ┬º┬ºgoto(addr969);
  816.                                                    ┬º┬ºpush(true);
  817.                                                 }
  818.                                                 if(eval("\x01") == 159)
  819.                                                 {
  820.                                                    set("\x01",eval("\x01") + 634);
  821.                                                    ┬º┬ºgoto(addr969);
  822.                                                 }
  823.                                                 break loop0;
  824.                                              }
  825.                                              set("\x01",eval("\x01") - 207);
  826.                                              startDrag(┬º┬ºpop(),┬º┬ºpop(),┬º┬ºpop(),┬º┬ºpop(),┬º┬ºpop(),┬º┬ºpop());
  827.                                              break loop0;
  828.                                           }
  829.                                           set("\x01",eval("\x01") - 101);
  830.                                           break loop0;
  831.                                        }
  832.                                        set("\x01",eval("\x01") - 607);
  833.                                        break loop0;
  834.                                     }
  835.                                     if(eval("\x01") == 133)
  836.                                     {
  837.                                        set("\x01",eval("\x01") + 597);
  838.                                        if(┬º┬ºpop())
  839.                                        {
  840.                                           set("\x01",eval("\x01") + 54);
  841.                                        }
  842.                                     }
  843.                                     else if(eval("\x01") == 759)
  844.                                     {
  845.                                        set("\x01",eval("\x01") - 388);
  846.                                     }
  847.                                     else if(eval("\x01") == 371)
  848.                                     {
  849.                                        set("\x01",eval("\x01") - 238);
  850.                                        ┬º┬ºpush(true);
  851.                                     }
  852.                                     else
  853.                                     {
  854.                                        if(eval("\x01") != 736)
  855.                                        {
  856.                                           if(eval("\x01") == 905)
  857.                                           {
  858.                                              set("\x01",eval("\x01") - 905);
  859.                                              break loop0;
  860.                                           }
  861.                                           break loop0;
  862.                                        }
  863.                                        set("\x01",eval("\x01") - 48);
  864.                                     }
  865.                                  }
  866.                                  while(true)
  867.                                  {
  868.                                     if(eval("\x01") == 75)
  869.                                     {
  870.                                        set("\x01",eval("\x01") + 663);
  871.                                        ┬º┬ºpush(true);
  872.                                        continue;
  873.                                     }
  874.                                     if(eval("\x01") == 784)
  875.                                     {
  876.                                        set("\x01",eval("\x01") - 445);
  877.                                        continue;
  878.                                     }
  879.                                     if(eval("\x01") == 738)
  880.                                     {
  881.                                        set("\x01",eval("\x01") - 79);
  882.                                        if(┬º┬ºpop())
  883.                                        {
  884.                                           set("\x01",eval("\x01") + 237);
  885.                                        }
  886.                                        continue;
  887.                                     }
  888.                                     if(eval("\x01") == 434)
  889.                                     {
  890.                                        set("\x01",eval("\x01") + 73);
  891.                                        var ┬º┬ºpop() = ┬º┬ºpop();
  892.                                        continue;
  893.                                     }
  894.                                     if(eval("\x01") == 285)
  895.                                     {
  896.                                        set("\x01",eval("\x01") + 451);
  897.                                        if(┬º┬ºpop())
  898.                                        {
  899.                                           set("\x01",eval("\x01") - 48);
  900.                                        }
  901.                                        continue;
  902.                                     }
  903.                                     if(eval("\x01") == 262)
  904.                                     {
  905.                                        set("\x01",eval("\x01") + 77);
  906.                                        continue;
  907.                                     }
  908.                                     if(eval("\x01") == 507)
  909.                                     {
  910.                                        set("\x01",eval("\x01") + 239);
  911.                                        ┬º┬ºpush("\x0f");
  912.                                        continue;
  913.                                     }
  914.                                     if(eval("\x01") == 523)
  915.                                     {
  916.                                        set("\x01",eval("\x01") - 152);
  917.                                        continue;
  918.                                     }
  919.                                     if(eval("\x01") == 547)
  920.                                     {
  921.                                        set("\x01",eval("\x01") + 435);
  922.                                        if(┬º┬ºpop())
  923.                                        {
  924.                                           set("\x01",eval("\x01") - 207);
  925.                                        }
  926.                                        continue;
  927.                                     }
  928.                                     if(eval("\x01") == 339)
  929.                                     {
  930.                                        set("\x01",eval("\x01") + 208);
  931.                                        ┬º┬ºpush(true);
  932.                                        continue;
  933.                                     }
  934.                                     if(eval("\x01") == 633)
  935.                                     {
  936.                                        set("\x01",eval("\x01") - 348);
  937.                                        ┬º┬ºpush(!┬º┬ºpop());
  938.                                        continue;
  939.                                     }
  940.                                     if(eval("\x01") == 280)
  941.                                     {
  942.                                        set("\x01",eval("\x01") + 662);
  943.                                        continue;
  944.                                     }
  945.                                     if(eval("\x01") == 688)
  946.                                     {
  947.                                        set("\x01",eval("\x01") + 217);
  948.                                        setProperty("∩┐╜∩┐╜pq", _alpha, 5);
  949.                                        set("o∩┐╜",getProperty("∩┐╜∩┐╜pq", _X));
  950.                                        set("f∩┐╜R0",getProperty("∩┐╜∩┐╜pq", _Y));
  951.                                        setProperty("∩┐╜∩┐╜pq", _X, random(320) - 160);
  952.                                        setProperty("∩┐╜∩┐╜pq", _Y, random(240) - 120);
  953.                                        set(┬º┬ºconstant(3),eval(┬º┬ºconstant(4))[┬º┬ºconstant(5)]);
  954.                                        break loop0;
  955.                                     }
  956.                                     if(eval("\x01") == 659)
  957.                                     {
  958.                                        set("\x01",eval("\x01") + 237);
  959.                                        break loop0;
  960.                                     }
  961.                                     if(eval("\x01") == 982)
  962.                                     {
  963.                                        set("\x01",eval("\x01") - 207);
  964.                                        break loop0;
  965.                                     }
  966.                                     if(eval("\x01") == 746)
  967.                                     {
  968.                                        set("\x01",eval("\x01") - 113);
  969.                                        ┬º┬ºpush(eval(┬º┬ºpop()));
  970.                                        continue;
  971.                                     }
  972.                                     if(eval("\x01") == 775)
  973.                                     {
  974.                                        set("\x01",eval("\x01") + 167);
  975.                                        continue;
  976.                                     }
  977.                                     if(eval("\x01") == 942)
  978.                                     {
  979.                                        set("\x01",eval("\x01") - 508);
  980.                                        ┬º┬ºpush("\x0f");
  981.                                        ┬º┬ºpush(1);
  982.                                        continue;
  983.                                     }
  984.                                     if(eval("\x01") == 367)
  985.                                     {
  986.                                        set("\x01",eval("\x01") - 179);
  987.                                        continue;
  988.                                     }
  989.                                     if(eval("\x01") == 896)
  990.                                     {
  991.                                        set("\x01",eval("\x01") - 708);
  992.                                        continue;
  993.                                     }
  994.                                     if(eval("\x01") == 188)
  995.                                     {
  996.                                        set("\x01",eval("\x01") + 709);
  997.                                        ┬º┬ºpush(true);
  998.                                        continue;
  999.                                     }
  1000.                                     if(eval("\x01") == 730)
  1001.                                     {
  1002.                                        set("\x01",eval("\x01") + 54);
  1003.                                        break loop0;
  1004.                                     }
  1005.                                     continue loop3;
  1006.                                  }
  1007.                               }
  1008.                            }
  1009.                         }
  1010.                         set("\x01",eval("\x01") + 332);
  1011.                         break;
  1012.                      }
  1013.                      if(eval("\x01") == 882)
  1014.                      {
  1015.                         set("\x01",eval("\x01") - 862);
  1016.                         if(function ┬º\x01\x02┬º()
  1017.                         {
  1018.                            return 256 % 511 * 5;
  1019.                         })
  1020.                         {
  1021.                            set("\x01",eval("\x01") + 146);
  1022.                         }
  1023.                      }
  1024.                      else if(eval("\x01") == 781)
  1025.                      {
  1026.                         set("\x01",eval("\x01") - 88);
  1027.                         ┬º┬ºpush(!function ┬º\x01\x02┬º()
  1028.                         {
  1029.                            return 256 % 511 * 5;
  1030.                         });
  1031.                      }
  1032.                      else if(eval("\x01") == 403)
  1033.                      {
  1034.                         set("\x01",eval("\x01") + 83);
  1035.                      }
  1036.                      else if(eval("\x01") == 549)
  1037.                      {
  1038.                         set("\x01",eval("\x01") - 465);
  1039.                         var ┬º┬ºpop() = function ┬º\x01\x02┬º()
  1040.                         {
  1041.                            return 256 % 511 * 5;
  1042.                         };
  1043.                      }
  1044.                      else if(eval("\x01") == 3)
  1045.                      {
  1046.                         set("\x01",eval("\x01") + 778);
  1047.                         ┬º┬ºpush(eval(function ┬º\x01\x02┬º()
  1048.                         {
  1049.                            return 256 % 511 * 5;
  1050.                         }));
  1051.                      }
  1052.                      else if(eval("\x01") == 83)
  1053.                      {
  1054.                         set("\x01",eval("\x01") - 22);
  1055.                      }
  1056.                      else
  1057.                      {
  1058.                         if(eval("\x01") != 693)
  1059.                         {
  1060.                            if(eval("\x01") == 707)
  1061.                            {
  1062.                               set("\x01",eval("\x01") - 707);
  1063.                               break;
  1064.                            }
  1065.                            break;
  1066.                         }
  1067.                         set("\x01",eval("\x01") - 610);
  1068.                         if(function ┬º\x01\x02┬º()
  1069.                         {
  1070.                            return 256 % 511 * 5;
  1071.                         })
  1072.                         {
  1073.                            set("\x01",eval("\x01") - 22);
  1074.                         }
  1075.                      }
  1076.                   }
  1077.                }
  1078.             }
  1079.          }
  1080.       }
  1081.    }
  1082. }
  1083.